home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 07 - 1991 / 07.02 Feb 91 / xserial source ƒ / xserial.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-07-27  |  4.1 KB  |  218 lines  |  [TEXT/KAHL]
  1. #include    <FileMgr.h>
  2. #include    <MacTypes.h>
  3. #include    <string.h>
  4. #include    <MemoryMgr.h>
  5. #include    <SerialDvr.h>
  6. #include     "xcmd.h"
  7.  
  8. void    setreturn(XCmdBlockPtr,char *);
  9. Handle    CopyStrToHand(char *);
  10.  
  11. #define    Mzero    34
  12. #define Azero    48
  13.  
  14.  
  15. #ifdef XTEST
  16. pascal void xserial(block)
  17. #else
  18. pascal void main(block)
  19. #endif
  20.     register    XCmdBlockPtr    block;
  21.     
  22. {
  23. #define    Bufsz    64
  24.     short            port;
  25.     unsigned short    baud;
  26.     short            databits;
  27.     short            stopbits;
  28.     short            parity;
  29.     short            handshake;
  30.     short            config;
  31.     short            error;
  32.     short            inport;
  33.     short            outport;
  34.     char            endline[5];
  35.     char            *s;
  36.     short            i;
  37.     long            length;
  38.     SerShk            shake;
  39.     
  40.     char            inbuf[Bufsz];
  41.     
  42.     error = 0; /* no error */
  43.     setreturn(block,"None");
  44.     switch (block->paramCount)
  45.         {
  46.         case 0: /* receive string */
  47.             inport = block->utillong1;
  48.             SerGetBuf(inport,&length);
  49.             if (length)
  50.                 {
  51.                 if (length < Bufsz)
  52.                     {
  53.                     FSRead(inport,&length,inbuf);
  54.                     inbuf[length] = 0; /* null terminate to make a C string */
  55.                     setreturn(block,inbuf);
  56.                     }
  57.                 }
  58.             else
  59.                 setreturn(block,"No data");
  60.             break;
  61.             
  62.         case 1: /* send string */
  63.             endline[0] = 13;
  64.             endline[1] = 10;
  65.             endline[2] = 0;
  66.             outport = block->utillong2;
  67.             s = (char *)*(block->params[0]);
  68.             length = s_len(s);
  69.             error = FSWrite(outport,&length,s);
  70.         /*    length = s_len(endline);
  71.             error = FSWrite(outport,&length,endline);*/
  72.             if (error)
  73.                 setreturn(block,"Write error");
  74.             return;
  75.             break;
  76.             
  77.         case 7: /* initialize */
  78.             port = (short) HandleToNum(block,block->params[0]);
  79.             baud = (short) HandleToNum(block,block->params[1]);
  80.             parity = *(char *)*(block->params[2]);
  81.             databits = (short) HandleToNum(block,block->params[3]);
  82.             stopbits = (short) HandleToNum(block,block->params[4]);
  83.             handshake = *(char *)*(block->params[5]);
  84.             s = (char *)*(block->params[6]);
  85.             i = 0;
  86.             while (s[i])
  87.                 {
  88.                 switch(s[i])
  89.                     {
  90.                     case 'R' : endline[i] = 13; break;
  91.                     case 'L' : endline[i] = 10; break;
  92.                     }
  93.                 i++;
  94.                 }
  95.                 endline[i] = 0;
  96.                             
  97.             switch (baud)
  98.                 {
  99.                 case 300 :    baud = 380; break;
  100.                 case 600 :    
  101.                 case 1200:    baud = 94; break;
  102.                 case 1800:
  103.                 case 2400:    baud = 46; break;
  104.                 case 3600:
  105.                 case 4800:    baud = 22; break;
  106.                 case 7200:
  107.                 case 9600:    baud = 18; break;
  108.                 case 19200:    baud = 4; break;
  109.                 case 57600:
  110.                 default :    baud = 94; break;
  111.                 }
  112.                 
  113.             switch (parity)
  114.                 {
  115.                 case 'N' :    parity = 8192; break;
  116.                 case 'O' :    parity = 12288; break;    
  117.                 case 'E' :    parity = 4096; break;
  118.                 default     :    parity = 8192; break;
  119.                 }
  120.                 
  121.             switch (databits)
  122.                 {
  123.                 case 7 :     databits = 1024; break;
  124.                 case 8 :     databits = 3072; break;
  125.                 default:    databits = 3072; break;
  126.                 }
  127.                 
  128.             switch (stopbits)
  129.                 {
  130.                 case 1 :    stopbits = 16384; break;
  131.                 case 2 :    stopbits = -16384; break;
  132.                 default:    stopbits = 16384; break;    
  133.                 }
  134.             
  135.             switch (handshake)
  136.                 {
  137.                 case 'H' :
  138.                 case 'S' :
  139.                 case 'N' :
  140.                 default :    shake.fXOn = 0;
  141.                             shake.fCTS = 0;
  142.                             shake.xOn  = 0;
  143.                             shake.xOff = 0;
  144.                             shake.errs = 0;
  145.                             shake.evts = 0;
  146.                             shake.fInX = 0;
  147.                             shake.fDTR = 0;
  148.                 }
  149.                 
  150.             config = baud + parity + databits + stopbits;
  151.             
  152.             switch (port)
  153.                 {
  154.                 case 1 :
  155.                     inport = -6;
  156.                     outport = -7;
  157.                     error = RAMSDOpen(sPortA);
  158.                     break;
  159.                 case 2 :
  160.                     inport = -8;
  161.                     outport = -9;
  162.                     error = RAMSDOpen(sPortB);
  163.                     break;
  164.                 }
  165.                 
  166.             if (error)
  167.                 {
  168.                 setreturn(block,"Can't open driver");
  169.                 }
  170.             else
  171.                 {
  172.                 error = SerReset(inport,config);
  173.                 if (error)
  174.                     setreturn(block,"Can't set in port");
  175.                 else
  176.                     {
  177.                     error = SerReset(outport,config);
  178.                     if (error)
  179.                         setreturn(block,"Can't set in port");
  180.                     else
  181.                         {
  182.                         error = SerHShake(inport,&shake) + SerHShake(outport,&shake);
  183.                         if (error)
  184.                             setreturn(block,"Can't set handshaking");
  185.                         else
  186.                             {
  187.                             block->utillong1 = inport;
  188.                             block->utillong2 = outport;
  189.                             }
  190.                         }
  191.                     }
  192.                 }
  193.             }
  194. }
  195.     
  196.     
  197.  
  198. void    setreturn(block,s)
  199.     XCmdBlockPtr    block;
  200.     char            *s;
  201. {
  202.     block->returnValue = (Handle) CopyStrToHand(s);
  203. }
  204.  
  205. Handle    CopyStrToHand(s)
  206.     char        *s;
  207. {
  208.     Handle        h;
  209.     
  210.     h = (Handle)NewHandle((long) s_len(s) + 1);
  211.     s_copy ((char *)(*h),s);
  212.     return(h);
  213. }
  214.  
  215.  
  216.  
  217.  
  218.